package cn.chengpengper.shortlink.util;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.List;

/**
 * @author huchengpeng
 * @version 1.0.0
 * @date 2023/6/18 21:19
 * @description JSON 工具类
 */
@Slf4j
public class JsonUtil {

    private static final ObjectMapper MAPPER = new ObjectMapper();

    static {
        // 设置可用单引号
        MAPPER.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);

        // 序列化的时候序列对象的所有属性
        MAPPER.setSerializationInclusion(JsonInclude.Include.ALWAYS);

        // 反序列化的时候如果多了其他属性，不抛异常
        MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        // 如果是空对象的时候，不抛异常
        MAPPER.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);

        // 取消时间的转化格式，默认是时间戳
        MAPPER.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS, false);

        // 设置要表现的时间格式
        MAPPER.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    }

    /**
     * 对象转为 JSON 字符串
     *
     * @param obj 实体对象
     * @return String Json串
     */
    public static String obj2Json(Object obj) {
        String jsonStr = null;
        try {
            jsonStr = MAPPER.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            log.error("json 序列化异常:", e);
        }
        return jsonStr;
    }

    /**
     * json 字符串转为对象
     *
     * @param jsonStr  json字符串
     * @param beanType 对象类型
     * @return T 对象
     */
    public static <T> T json2Obj(String jsonStr, Class<T> beanType) {
        T obj = null;
        try {
            obj = MAPPER.readValue(jsonStr, beanType);
        } catch (JsonProcessingException e) {
            log.error("json 反序列化异常:", e);
        }
        return obj;
    }

    /**
     * json 数据转换为 pojo 对象 list
     *
     * @param jsonData json字符串
     * @param beanType 对象类型
     * @return List<T> 对象列表
     */
    public static <T> List<T> json2List(String jsonData, Class<T> beanType) {
        JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
        try {
            return MAPPER.readValue(jsonData, javaType);
        } catch (JsonProcessingException e) {
            log.error("json 反序列化异常:", e);
        }
        return null;
    }

    /**
     * 对象转换为 byte 数组
     *
     * @param obj 对象
     * @return byte[] 字节数组
     */
    public static byte[] obj2Bytes(Object obj) {
        byte[] byteArr = null;
        try {
            byteArr = MAPPER.writeValueAsBytes(obj);
        } catch (JsonProcessingException e) {
            log.error("json 序列化异常:", e);
        }
        return byteArr;
    }

    /**
     * byte 数组转为对象
     *
     * @param byteArr  字节数组
     * @param beanType 对象类型
     * @return T 对象
     */
    public static <T> T bytes2Obj(byte[] byteArr, Class<T> beanType) {
        T obj = null;
        try {
            obj = MAPPER.readValue(byteArr, beanType);
        } catch (IOException e) {
            log.error("json 反序列化异常:", e);
        }
        return obj;
    }

}
